package modele;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.Polygon;
import java.awt.image.ImageObserver;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import position.PositionChamp;

/**
 * Element du plateau (terrain) qui relie deux champs
 * On peut placer une barrière sur cet élément
 * 
 * @author DONG Xiangxiang Durand Rémi
 */
public class Passage implements Serializable{
    private Polygon polygon;
    private int nbPoints=4;
    private Point centre;
    private List<Champ> champs;
    private Barriere barriere;
    private Point index;
    private static double COTEPASSAGE=29.0;
    private double startAngle;
    private boolean disponible;
    private ImageObserver observer;
    public Passage(){
        this(new Point(250,250),0);
    }
//    
    public Passage(Point p,double startAngle){
        polygon = new Polygon();
        centre = new Point();
        centre = p;
        disponible = true;
        index = new Point();
        champs = new ArrayList<Champ>();
        int ox = p.x;
        int oy = p.y;
        double angle = 2*Math.PI/nbPoints;
        this.startAngle=startAngle;
        double r= COTEPASSAGE;
        for(int i=0; i<nbPoints; i++) {
            int x = (int)(ox+r*Math.cos(startAngle+i*angle));
            int y = (int)(oy+r*Math.sin(startAngle+i*angle));
            polygon.addPoint(x,y);
        }
    }
    public void paint(Graphics g) {
        g.setColor(Color.yellow);
        g.fillPolygon(polygon.xpoints, polygon.ypoints, nbPoints); 
        if(barriere!=null) {
            g.setColor(Color.black);
            g.drawLine(polygon.xpoints[1], polygon.ypoints[1], polygon.xpoints[3], polygon.ypoints[3]);
            g.drawLine(polygon.xpoints[0], polygon.ypoints[0], polygon.xpoints[2], polygon.ypoints[2]);
        }
    }

    public Polygon getPolygon() {
        return polygon;
    }
    public boolean contains(Point p){
        return polygon.contains(p.x, p.y);
    }
    public Point getIndex() {
        return index;
    }

    public void setIndex(int niveau, int num) {
        this.index.setLocation(niveau,num);
    }
    
    public int getNbPoints() {
        return nbPoints;
    }

    public static double getCOTEPASSAGE() {
        return COTEPASSAGE;
    }    

    public List<Champ> getChamps() {
        return champs;
    }

    public void setChamps(PositionChamp pc,Champ champ) {
        this.champs.add(pc.getValeur(), champ);
    }

    public Point getCentre() {
        return centre;
    }
    public double getStartAngle() {
        return startAngle;
    }
    public boolean isDisponible() {
        return disponible;
    }

    public void setDisponible(boolean valeur) {
        if(!valeur){
            this.barriere = new Barriere();
        }
        
        this.disponible = valeur;
    }
    
    /**
     * Compare le passage courant avec un passage
     * @param passage
     * @return true si les passages sont égaux
     */
    public boolean equals(Passage passage){
        boolean egaux = false;
        
        if(this.centre.equals(passage.getCentre())){
            egaux = true;
        }
        
        return egaux;
    }
    
    /**
     * Retourne le champ connecté au passage
     * @param champ que l'on connait
     * @return le 2° champ associé au passage
     */
    public Champ champOppose(Champ champ){
        Champ champRetour = null;
        
        // comme il y a que deux champs associé à un passage c'est forcement le champ 0 ou 1
        
        int i=0;
        while(champRetour == null && i < champs.size()){
            if(champs.get(i) != champ){
                champRetour = champs.get(i);
            }
            i++;
        }
        
        return champRetour;
    }
    
}